home *** CD-ROM | disk | FTP | other *** search
/ System Booster / System Booster.iso / Texteditors / XDME / Src / Mod / Macros.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-09-27  |  6.3 KB  |  269 lines
  1. /******************************************************************************
  2.  
  3.     MODUL
  4.     lowlevelmacros.c
  5.  
  6.     DESCRIPTION
  7.     die schnittstelle zu den wichtigsten Macro-funktionen,
  8.     die von anderen Moduln verwendet werden duerfen.
  9.  
  10.     NOTES
  11.     dies ist nur ein Dummy - Modul, das zwar alle
  12.     Funktionen exportiert, die beschrieben wurden,
  13.     ihre Realisierung ist jedoch stark eingeschraenkt,
  14.     sie sind auf einfache Strings zurueckgeschraubt,
  15.     so dass die sie verwendenden Moduln wie vorher
  16.     angesprochen werden koennen.
  17.  
  18.     BUGS
  19.  
  20.     TODO
  21.     bei Gelegenheit sollte dieses Modul komplett neu geschrieben werden
  22.     und mit alias.c und main.c neu abgestimmt werden
  23.     (so dass main.c callmacro verwendet neque vero do_command)
  24.  
  25.     EXAMPLES
  26.  
  27.     SEE ALSO
  28.  
  29.     INDEX
  30.  
  31.     HISTORY
  32.  
  33. ******************************************************************************/
  34.  
  35. /**************************************
  36.         Includes
  37. **************************************/
  38. #include "defs.h"
  39.  
  40.  
  41. /**************************************
  42.         Globale Variable
  43. **************************************/
  44. Prototype UBYTE * GetArg      (int);
  45. Prototype UBYTE * CommandName (void);
  46.  
  47.  
  48. Prototype void clear_record    (void);
  49. Prototype void start_recording    (void);
  50. Prototype void end_recording    (void);
  51. Prototype void replay_record    (void);
  52. Prototype void do_saverecord    (void);
  53. Prototype void add_record    (char * string);
  54.  
  55.  
  56. /**************************************
  57.       Interne Defines & Strukturen
  58. **************************************/
  59.  
  60.  
  61. /**************************************
  62.         Interne Variable
  63. **************************************/
  64. static char tempmacro_buffer[LINE_LENGTH];
  65.  
  66.  
  67. /**************************************
  68.        Interne Prototypes
  69. **************************************/
  70.  
  71.  
  72.         /***********************************************
  73.         ***********************************************
  74.  
  75.         Dies ist lediglich eine Uebergangsloesung,
  76.         solange wir alias.c und main.c noch nicht
  77.         umgeschrieben haben
  78.  
  79.         ***********************************************
  80.         ***********************************************/
  81.  
  82.  
  83.  
  84.  
  85. UBYTE * CommandName (void)
  86. {
  87.     return (av[0]);
  88. } /* CommandName */
  89.  
  90. UBYTE * GetArg (int num)
  91. {
  92.     return(av[num]);
  93. } /* GetArg */
  94.  
  95.  
  96.  
  97.  
  98. /*
  99. **  MACRO RECORDER
  100. **    we can record one input - sequence and replay it
  101. **
  102. **    there are 3 functions:
  103. **
  104. **  recording
  105. **    int Start_recording (void)
  106. **    int add_record        (char * string)
  107. **    int end_recording   (void)
  108. **
  109. **  playing
  110. **    int replay_record   (void)
  111. **
  112. **  saving
  113. **    int save_record     (FILE * fo)
  114. **        (can be sourced)
  115. **
  116. */
  117.  
  118. static struct MinList record =    /* list to contain the macros */
  119. {
  120.     (struct MinNode *)&record.mlh_Tail, NULL,
  121.     (struct MinNode *)&record.mlh_Head
  122. };
  123. static WORD          record_replaying     = 0;              /* security to avoid endless loops */
  124.  
  125. struct LongNode {
  126.     struct MinNode node;
  127.     char       com[0];
  128. };
  129.  
  130. void clear_record (void)
  131. {
  132.     struct LongNode * ln;
  133.  
  134.     while (ln = (struct LongNode *)RemHead ((struct List *)&record)) {
  135.     FreeMem (ln, sizeof (struct MinNode) + 1 + strlen (ln->com));
  136.     } /* while */
  137. } /* clear_record */
  138.  
  139. void start_recording (void)
  140. {
  141.     if (!record_replaying) {
  142.     if (MacroRecord == 0) {
  143.         clear_record();
  144.     } /* if */
  145.  
  146.     MacroRecord ++;
  147.     } else {
  148.     error ("%s:\nYou can NOT start recording,\nwhile You are replaying a record", av[0]);
  149.     } /* if */
  150. } /* start_recording */
  151.  
  152. void end_recording (void)
  153. {
  154.     if (MacroRecord) {
  155.     MacroRecord --;
  156.  
  157.     {
  158.         char ab = globalflags.Abortcommand;
  159.         error ("recorder ended!");
  160.         globalflags.Abortcommand = ab;
  161.     }
  162.  
  163. #    ifdef NOT_DEF
  164.         /* strenggenommen muessten wir zuallererstden recorderend aus dem letzten string herausfiltern */
  165.         /* was aber, wenn der nicht als command sondern als macro kam ??? */
  166.         if (MacroRecord == ~0) {
  167.         struct LongNode * ln;
  168.         if (ln = (struct LongNode *)RemTail ((struct List *)&record)) {
  169.             strcpy (tmp_buffer, ln->com);
  170.  
  171.         } /* if */
  172.         } /* if */
  173. #    endif
  174.  /* } else if (!record_replaying) { */
  175.      /* error ("%s:\nYou can NOT end recording,\nif You are NOT recording", av[0]); */
  176.     } /* if */
  177. } /* end_recording */
  178.  
  179. void add_record (char * string)
  180. {
  181.     if (!record_replaying) {
  182.     struct LongNode * ln;
  183.  
  184.     if (ln = AllocMem (sizeof (struct MinNode) + 1 + strlen (string), MEMF_ANY)) {
  185.         strcpy (ln->com, string);
  186.         AddTail ((struct List *)&record, (struct Node *)ln);
  187.     } else {
  188.         nomemory ();     /* do NOT abort - we have to execute commands, too */
  189.     } /* if */
  190.  
  191.     if (breakcheck()) {  /* that way we might have a sure record-terminator - the CTL-C signal */
  192.         end_recording ();
  193.     } /* if */
  194.     } /* if */
  195. } /* add_record */
  196.  
  197. void replay_record (void)
  198. {
  199.     if (!record_replaying) {
  200.     if (GetHead (&record)) {
  201.         char * buffer;
  202.         /* We use a run-time allocated buffer */
  203.         if (!(buffer = AllocMem (LINE_LENGTH, MEMF_ANY))) {
  204.         nomemory ();     /* error() NEEDS memory for itself */
  205.         globalflags.Abortcommand = 1;
  206.         return;
  207.         } else {
  208.         struct LongNode * ln;
  209.  
  210.         for (ln = GetHead (&record); ln; ln = GetSucc (ln)) {
  211.             strncpy (buffer, ln->com, LINE_LENGTH-1);
  212.             do_command (buffer);
  213.  
  214.             /* You can NOT terminate Your record by errors */
  215.             clearbreaks ();
  216.  
  217.             /* You can break Your record by pressing Ctrl-C */
  218.             if (breakcheck ()) {
  219.             globalflags.Abortcommand = 1;
  220.             break;
  221.             } /* if */
  222.         } /* for */
  223.  
  224.         FreeMem (buffer, LINE_LENGTH);
  225.         } /* if alloced */
  226.     } /* if */
  227.     } else {
  228.     error ("%s:\nYou can NOT start replaying a record,\nwhile You are already replaying it", av[0]);
  229.     } /* if not already replaying */
  230. } /* replay_record */
  231.  
  232. void save_record (FILE * fo)
  233. {
  234.     if (fo) {
  235.     struct LongNode * ln;
  236.     for (ln = GetHead (&record); ln; ln = GetSucc (ln)) {
  237.         sprintf (tmp_buffer, "%s\n", ln->com);
  238.         if (fputs (tmp_buffer, fo) < 0) {
  239.         error ("%s:\nError while writing the\ncurrent record!", av[0]);
  240.         break;
  241.         } /* if */
  242.     } /* for */
  243.     } /* if */
  244. } /* save_record */
  245.  
  246. void do_saverecord (void)
  247. {
  248.     FILE  * fo;
  249.  
  250.     if (!GetHead (&record)) {
  251.     error ("%s:\nCan not save a record,\n if there is NO record!", av[0]);
  252.     } else {
  253.     if (fo = fopen (av[1], "w")) {
  254.         save_record (fo);
  255.         fclose (fo);
  256.     } else {
  257.         error ("%s:\n Can not open File\n'%s' for output", av[0], av[1]);
  258.     } /* if */
  259.     } /* if */
  260. } /* do_saverecord */
  261.  
  262.  
  263.  
  264.  
  265.  
  266. /******************************************************************************
  267. *****  ENDE macros.c
  268. ******************************************************************************/
  269.